/*
本项目原文链接： https://blog.csdn.net/weixin_53946312/article/details/124778530
*/

#include <iostream>
#include <thread>
#include "ThreadCache.h"
#include "CentralCache.h"
#include "PageCache.h"
#include "ConcurrentAlloc.hpp"

void p(size_t a)
{
	std::cout << a << std::endl;
}

void test_SizeClass()
{
	ThreadCache objThreadCache;
	objThreadCache.Allocate(8);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(9);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1007);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1008);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1009);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1024);
	std::cout << "------------------------------------------------------------------\n" << std::endl;

	objThreadCache.Allocate(1024);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1151);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1152);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(1153);
	std::cout << "------------------------------------------------------------------\n" << std::endl;

	objThreadCache.Allocate(8 * 1024);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(8 * 1024 + 1023);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(8 * 1024 + 1024);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(8 * 1024 + 1025);
	std::cout << "------------------------------------------------------------------\n" << std::endl;


	objThreadCache.Allocate(64 * 1024);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(64 * 1024 + 8 * 1024 - 1);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(64 * 1024 + 8 * 1024);
	std::cout << "------------------------------" << std::endl;
	objThreadCache.Allocate(64 * 1024 + 8 * 1024 + 1);
	std::cout << "------------------------------" << std::endl;
}

//void test_SpanList()
//{
//	using namespace std;
//	SpanList lst;
//
//	cout << lst.m_head << endl;
//
//	for (int i = 0; i < 10; ++i)
//	{
//		Span* p = new Span;
//		p->objSize = i;
//		lst.PushFront(p);
//	}
//
//	Span* p = lst.Begin();
//	while (p != lst.m_head)
//	{
//		cout << "num: " << p->objSize << endl;
//		p = p->next;
//	}
//
//	cout << "=============================" << endl;
//	for (int i = 0; i < 5; i++)
//	{
//		lst.PopFront();
//	}
//
//	p = lst.Begin();
//	while (p != lst.m_head)
//	{
//		cout << "num: " << p->objSize << endl;
//		p = p->next;
//	}
//
//	cout << "=============================" << endl;
//
//	for (int i = 5; i < 7; ++i)
//	{
//		Span* p = new Span;
//		p->objSize = i;
//		lst.PushFront(p);
//	}
//
//
//	p = lst.Begin();
//	while (p != lst.m_head)
//	{
//		cout << "num: " << p->objSize << endl;
//		p = p->next;
//	}
//
//	cout << "=============================" << endl;
//
//
//	for (int i = 0; i < 7; i++)
//	{
//		lst.PopFront();
//	}
//
//	p = lst.Begin();
//	while (p != lst.m_head)
//	{
//		cout << "num: " << p->objSize << endl;
//		p = p->next;
//	}
//
//	cout << "=============================" << endl;
//
//	cout << lst.Empty() << endl;
//
//	cout << lst.m_head << "  " << lst.m_head->next << " " << lst.m_head->prev << endl;
//
//	for (int i = 5; i < 7; ++i)
//	{
//		Span* p = new Span;
//		p->objSize = i;
//		lst.PushFront(p);
//	}
//	cout << lst.Empty() << endl;
//
//	p = lst.Begin();
//	while (p != lst.m_head)
//	{
//		cout << "num: " << p->objSize << endl;
//		p = p->next;
//	}
//
//	cout << "=============================" << endl;
//
//}


void test_PageCache()
{
	//PageCache* obj = PageCache::GetInstance();
	//auto a = obj->NewSpan(10);
	//auto b = obj->NewSpan(5);
	//obj->ReleaseSpanToPageCache(b);

	CentralCache* o = CentralCache::GetInstance();
	o->ReleaseListToSpans(nullptr, 0);
}


void TestMemoryPool()
{
	using namespace std;
	int* a = (int*)ConcurrentAlloc(sizeof(int));
	*a = 10;
	int* b = (int*)ConcurrentAlloc(sizeof(int));
	*b = 20;
	cout << a << endl;
	cout << *a << endl;
	cout << b << endl;
	cout << *b << endl;

	ConcurrentFree(a);
	ConcurrentFree(b);
}

int main(void)
{
	std::thread th1(TestMemoryPool);
	std::thread th2(TestMemoryPool);
	std::thread th3(TestMemoryPool);
	th1.join();
	th2.join();
	th3.join();

	PageCache::GetInstance()->testPrintSpanMap();

	return 0;
}